home *** CD-ROM | disk | FTP | other *** search
/ Disc to the Future 2 / Disc to the Future Part II Programmer's Reference (Wayzata Technology)(6013)(1992).bin / MAC / MPW_TOOL / TOOLS / TOOLS_WI / CTEX__ / PKTOPX.C < prev    next >
Text File  |  1987-05-25  |  12KB  |  394 lines
  1. /* pktopx in C by Tomas Rokicki */
  2. #include <stdio.h>
  3. #define namelength 80 
  4. #define terminallinelength 132 
  5. #define maxdiv32 100 
  6. #define onefourth 1073741824 
  7.  
  8. #define incr(a) (a++)
  9. #define decr(a) (a--)
  10. #define true (1)
  11. #define false (0)
  12. #define round(a) ((int)(a+0.5))
  13.  
  14.   typedef int integer ;
  15.   typedef unsigned char quarterword ;
  16.   typedef char boolean ;
  17.   typedef quarterword eightbits ; 
  18.   typedef FILE *bytefile ; 
  19.   bytefile pxlfile ; 
  20.   bytefile pkfile ; 
  21.   char pxlname[81], pkname[81] ; 
  22.   integer pxlloc, pkloc ; 
  23.   integer magnification ; 
  24.   integer designsize ; 
  25.   integer checksum ; 
  26.   integer hppp, vppp ; 
  27.   integer i, j ; 
  28.   integer endofpacket ; 
  29.   integer rasterpointer[128] ; 
  30.   integer sizes[128] ; 
  31.   integer offsets[128] ; 
  32.   integer tfmwidth[128] ; 
  33.   integer dynf ; 
  34.   integer car ; 
  35.   integer cheight, cwidth ; 
  36.   integer coffsets ; 
  37.   integer wordwidth ; 
  38.   integer horesc ; 
  39.   integer packetlength ; 
  40.   eightbits inputbyte ; 
  41.   eightbits bitweight ; 
  42.   eightbits nybble ; 
  43.   integer row[101] ; 
  44.   integer word ; 
  45.   integer wordweight ; 
  46.   integer power[32] ; 
  47.   integer gpower[33] ; 
  48.   integer repeatcount ; 
  49.   integer rowsleft ; 
  50.   boolean turnon ; 
  51.   integer hbit ; 
  52.   integer count ; 
  53.   integer rp ; 
  54.   integer dirptr ; 
  55.   integer flagbyte ; 
  56.   integer haveext ; 
  57.   integer lastext ; 
  58.   int gargc ;
  59.   char **gargv ;
  60.   initialize () { integer i ; 
  61.     printf ( "This is PKtoPX, C Version 2.1\n" ) ; 
  62.     power [ 0 ] = 1 ; 
  63.     for ( i = 1 ; i <= 30 ; i ++ ) power [ i ] = power [ i - 1 ] * 2 ; 
  64.       power [ 31 ] = - onefourth - onefourth ; 
  65.     gpower [ 0 ] = 0 ; 
  66.     for ( i = 1 ; i <= 32 ; i ++ ) gpower [ i ] = gpower [ i - 1 ] + power [ 
  67.       i - 1 ] ; 
  68.       } 
  69.   jumpout () { exit ( 1 ) ; 
  70.     } 
  71.   openpxlfile () { pxlfile = fopen ( pxlname , "w" ) ; 
  72.     pxlloc = 0 ; 
  73.     } 
  74.   openpkfile () { pkfile = fopen ( pkname , "r" ) ; 
  75.     pkloc = 0 ; 
  76.     } 
  77.   pixelinteger ( i ) 
  78.   integer i ; 
  79.   { putc ( (char) ( (i >> 24) & 255 ) , pxlfile ) ; 
  80.     putc ( (char) ( (i >> 16) & 255 ) , pxlfile ) ; 
  81.     putc ( (char) ( (i >> 8) & 255) , pxlfile ) ; 
  82.     putc ( (char) ( i & 255 ) , pxlfile ) ; 
  83.     incr ( pxlloc ) ;
  84.     } 
  85.   eightbits pkbyte () { incr ( pkloc ) ; 
  86.     return ( getc ( pkfile ) ) ; 
  87.     } 
  88.   integer get16 () { integer a ; 
  89.     a = pkbyte () ; 
  90.     return ( a * 256 + pkbyte () ) ; 
  91.     } 
  92.   integer get32 () { integer a ; 
  93.     a = get16 () ; 
  94.     if ( a > 32767 ) a = a - 65536 ; 
  95.     return ( a * 65536 + get16 () ) ; 
  96.     } 
  97.   integer getnyb () { eightbits temp ; 
  98.     if ( bitweight == 0 ) 
  99.     { inputbyte = pkbyte () ; 
  100.       bitweight = 16 ; 
  101.       } 
  102.     temp = inputbyte / bitweight ; 
  103.     inputbyte = inputbyte - temp * bitweight ; 
  104.     bitweight = bitweight / 16 ; 
  105.     return ( temp ) ; 
  106.     } 
  107.   boolean getbit () { boolean temp ; 
  108.     bitweight = bitweight / 2 ; 
  109.     if ( bitweight == 0 ) 
  110.     { inputbyte = pkbyte () ; 
  111.       bitweight = 128 ; 
  112.       } 
  113.     temp = inputbyte >= bitweight ; 
  114.     if ( temp ) inputbyte = inputbyte - bitweight ; 
  115.     return ( temp ) ; 
  116.     } 
  117.   integer pkpackednum () { integer i, j, k ; 
  118.     i = getnyb () ; 
  119.     if ( i == 0 ) 
  120.     { do { j = getnyb () ; 
  121.         incr ( i ) ; 
  122.         } while ( ! ( j != 0 ) ) ; 
  123.       while ( i > 0 ) 
  124.         { j = j * 16 + getnyb () ; 
  125.           decr ( i ) ; 
  126.           } 
  127.         return ( j - 15 + ( 13 - dynf ) * 16 + dynf ) ; 
  128.       } 
  129.     else if ( i <= dynf ) return ( i ) ; 
  130.     else if ( i < 14 ) return ( ( i - dynf - 1 ) * 16 + getnyb () + dynf + 1 
  131.     ) ; 
  132.     else 
  133.     { if ( i == 14 ) repeatcount = pkpackednum () ; 
  134.       else repeatcount = 1 ; 
  135.       return ( pkpackednum () ) ; 
  136.       } 
  137.     } 
  138.   skipspecials () { integer i, j, k ; 
  139.     do { flagbyte = pkbyte () ; 
  140.       if ( flagbyte >= 240 ) switch ( flagbyte ) 
  141.       { case 240 : 
  142.         case 241 : 
  143.         case 242 : 
  144.         case 243 : 
  145.         
  146.         { i = 0 ; 
  147.           for ( j = 240 ; j <= flagbyte ; j ++ ) i = 256 * i + pkbyte () ; 
  148.             for ( j = 1 ; j <= i ; j ++ ) k = pkbyte () ; 
  149.             } 
  150.         break ; 
  151.         case 244 : 
  152.         i = get32 () ; 
  153.         break ; 
  154.         case 245 : 
  155.         
  156.         { ; 
  157.           } 
  158.         break ; 
  159.         case 246 : 
  160.         
  161.         { ; 
  162.           } 
  163.         break ; 
  164.         case 247 : 
  165.         case 248 : 
  166.         case 249 : 
  167.         case 250 : 
  168.         case 251 : 
  169.         case 252 : 
  170.         case 253 : 
  171.         case 254 : 
  172.         case 255 : 
  173.         
  174.         { printf ( " Unexpected %d!\n" , flagbyte ) ; 
  175.           jumpout () ; 
  176.           } 
  177.         break ; 
  178.         } } while ( ! ( ( flagbyte < 240 ) || ( flagbyte == 245 ) ) ) ; 
  179.     } 
  180.   dialog () { integer i ; 
  181.     if ( ( gargc < 2 ) || ( gargc > 3 ) ) 
  182.     { printf ( " Usage: pktopx pkfile[.pk] [pxlfile[.nnnnpxl]]\n" ) 
  183.       ; 
  184.       jumpout () ; 
  185.       } 
  186.     strcpy ( pkname , gargv [ 1 ] ) ; 
  187.     lastext = - 1 ; 
  188.     i = 0 ; 
  189.     while ( pkname [ i ] != 0 ) 
  190.       { if ( pkname [ i ] == '.' ) lastext = i ; 
  191.         else if ( pkname [ i ] == '/' ) lastext = - 1 ; 
  192.         incr ( i ) ; 
  193.         } 
  194.       if ( lastext == - 1 ) 
  195.     { strcpy ( pkname + i , ".pk" ) ; 
  196.       lastext = i ; 
  197.       } 
  198.     if ( gargc == 3 ) 
  199.     { strcpy ( pxlname , gargv [ 2 ] ) ; 
  200.       haveext = true ; 
  201.       } 
  202.     else 
  203.     { strcpy ( pxlname , pkname ) ; 
  204.       haveext = false ; 
  205.       } 
  206.     } 
  207.   main (argc, argv) 
  208. int argc ;
  209. char *argv[] ;
  210. { gargc = argc ;
  211.   gargv = argv ;
  212.   initialize () ; 
  213.   dialog () ; 
  214.   openpkfile () ; 
  215.   if ( pkbyte () != 247 ) 
  216.   { printf ( " Bad pk file!  pre command missing.\n" ) ; 
  217.     jumpout () ; 
  218.     } 
  219.   if ( pkbyte () != 89 ) 
  220.   { printf ( " Wrong version of packed file!.\n" ) ; 
  221.     jumpout () ; 
  222.     } 
  223.   j = pkbyte () ; 
  224.   for ( i = 1 ; i <= j ; i ++ ) hppp = pkbyte () ; 
  225.     designsize = get32 () ; 
  226.   checksum = get32 () ; 
  227.   hppp = get32 () ; 
  228.   vppp = get32 () ; 
  229.   if ( hppp != vppp ) printf ( "Warning:  aspect ratio not 1:1!\n" ) ; 
  230.   magnification = round ( hppp * 72.27 * 5 / 65536 ) ; 
  231.   if ( ! haveext ) 
  232.   { i = round ( hppp * 72.27 * 5 / 65536 ) ; 
  233.     sprintf ( pxlname + lastext , ".%dpxl" , i ) ; 
  234.     } 
  235.   openpxlfile () ; 
  236.   pixelinteger ( 1001 ) ; 
  237.   skipspecials () ; 
  238.   while ( flagbyte != 245 ) 
  239.     { dynf = flagbyte / 16 ; 
  240.       flagbyte = flagbyte % 16 ; 
  241.       turnon = flagbyte >= 8 ; 
  242.       if ( turnon ) flagbyte = flagbyte - 8 ; 
  243.       if ( flagbyte == 7 ) 
  244.       { packetlength = get32 () ; 
  245.         car = get32 () ; 
  246.         endofpacket = packetlength + pkloc ; 
  247.         if ( ( car > 127 ) || ( car < 0 ) ) goto lab9997 ; 
  248.         tfmwidth [ car ] = get32 () ; 
  249.         horesc = get32 () ; 
  250.         i = get32 () ; 
  251.         cwidth = get32 () ; 
  252.         cheight = get32 () ; 
  253.         if ( ( cwidth < 0 ) || ( cheight < 0 ) || ( cwidth > 65535 ) || ( 
  254.         cheight > 65535 ) ) goto lab9997 ; 
  255.         wordwidth = ( cwidth + 31 ) / 32 ; 
  256.         sizes [ car ] = cwidth * 65536 + cheight ; 
  257.         i = get32 () ; 
  258.         j = get32 () ; 
  259.         if ( j < 0 ) j = j + 65536 ; 
  260.         offsets [ car ] = i * 65536 + j ; 
  261.         } 
  262.       else if ( flagbyte > 3 ) 
  263.       { packetlength = ( flagbyte - 4 ) * 65536 + get16 () ; 
  264.         car = pkbyte () ; 
  265.         endofpacket = packetlength + pkloc ; 
  266.         if ( car > 127 ) goto lab9997 ; 
  267.         i = pkbyte () ; 
  268.         tfmwidth [ car ] = i * 65536 + get16 () ; 
  269.         horesc = get16 () ; 
  270.         cwidth = get16 () ; 
  271.         cheight = get16 () ; 
  272.         wordwidth = ( cwidth + 31 ) / 32 ; 
  273.         sizes [ car ] = cwidth * 65536 + cheight ; 
  274.         i = get16 () ; 
  275.         j = get16 () ; 
  276.         if ( i > 32767 ) i = i - 65536 ; 
  277.         offsets [ car ] = i * 65536 + j ; 
  278.         } 
  279.       else 
  280.       { packetlength = flagbyte * 256 + pkbyte () ; 
  281.         car = pkbyte () ; 
  282.         endofpacket = packetlength + pkloc ; 
  283.         if ( car > 127 ) goto lab9997 ; 
  284.         i = pkbyte () ; 
  285.         tfmwidth [ car ] = i * 65536 + get16 () ; 
  286.         horesc = pkbyte () ; 
  287.         cwidth = pkbyte () ; 
  288.         cheight = pkbyte () ; 
  289.         wordwidth = ( cwidth + 31 ) / 32 ; 
  290.         sizes [ car ] = cwidth * 65536 + cheight ; 
  291.         i = pkbyte () ; 
  292.         j = pkbyte () ; 
  293.         if ( i > 127 ) i = i - 256 ; 
  294.         if ( j > 127 ) j = j + 255 * 256 ; 
  295.         offsets [ car ] = i * 65536 + j ; 
  296.         } 
  297.       if ( rasterpointer [ car ] != 0 ) 
  298.       { printf ( " Second time this character used!\n" ) ; 
  299.         jumpout () ; 
  300.         } 
  301.       rasterpointer [ car ] = pxlloc ; 
  302.       bitweight = 0 ; 
  303.       if ( dynf == 14 ) 
  304.       { bitweight = 0 ; 
  305.         for ( i = 1 ; i <= cheight ; i ++ ) 
  306.           { word = 0 ; 
  307.             wordweight = 31 ; 
  308.             for ( j = 1 ; j <= cwidth ; j ++ ) 
  309.               { if ( getbit () ) word = word + power [ wordweight ] ; 
  310.                 wordweight = wordweight - 1 ; 
  311.                 if ( wordweight == - 1 ) 
  312.                 { pixelinteger ( word ) ; 
  313.                   wordweight = 31 ; 
  314.                   } 
  315.                 } 
  316.               if ( wordweight < 31 ) pixelinteger ( word ) ; 
  317.             } 
  318.           } 
  319.       else 
  320.       { rowsleft = cheight ; 
  321.         hbit = cwidth ; 
  322.         repeatcount = 0 ; 
  323.         wordweight = 32 ; 
  324.         word = 0 ; 
  325.         rp = 1 ; 
  326.         while ( rowsleft > 0 ) 
  327.           { count = pkpackednum () ; 
  328.             while ( count > 0 ) 
  329.               { if ( ( count < wordweight ) && ( count < hbit ) ) 
  330.                 { if ( turnon ) word = word + gpower [ wordweight ] - gpower 
  331.                   [ wordweight - count ] ; 
  332.                   hbit = hbit - count ; 
  333.                   wordweight = wordweight - count ; 
  334.                   count = 0 ; 
  335.                   } 
  336.                 else if ( ( count >= hbit ) && ( hbit <= wordweight ) ) 
  337.                 { if ( turnon ) word = word + gpower [ wordweight ] - gpower 
  338.                   [ wordweight - hbit ] ; 
  339.                   row [ rp ] = word ; 
  340.                   for ( i = 0 ; i <= repeatcount ; i ++ ) for ( j = 1 ; j <= 
  341.                       wordwidth ; j ++ ) pixelinteger ( row [ j ] ) ; 
  342.                       rowsleft = rowsleft - repeatcount - 1 ; 
  343.                   repeatcount = 0 ; 
  344.                   rp = 1 ; 
  345.                   word = 0 ; 
  346.                   wordweight = 32 ; 
  347.                   count = count - hbit ; 
  348.                   hbit = cwidth ; 
  349.                   } 
  350.                 else 
  351.                 { if ( turnon ) word = word + gpower [ wordweight ] ; 
  352.                   row [ rp ] = word ; 
  353.                   rp = rp + 1 ; 
  354.                   word = 0 ; 
  355.                   count = count - wordweight ; 
  356.                   hbit = hbit - wordweight ; 
  357.                   wordweight = 32 ; 
  358.                   } 
  359.                 } 
  360.               turnon = ! turnon ; 
  361.             } 
  362.           if ( ( rowsleft != 0 ) || ( hbit != cwidth ) ) 
  363.         { printf ( " Bad pk file---more bits than required!\n" ) ; 
  364.           jumpout () ; 
  365.           } 
  366.         } 
  367.       if ( endofpacket != pkloc ) 
  368.       { printf ( " Bad pk file!  Bad packet length.\n" ) ; 
  369.         jumpout () ; 
  370.         } 
  371.       goto lab9998 ; 
  372.       lab9997 : while ( pkloc != endofpacket ) i = pkbyte () ; 
  373.         printf ( "Character %d out of range!\n" , car ) ; 
  374.       lab9998 : skipspecials () ; 
  375.       } 
  376.     while ( ! feof ( pkfile ) ) i = pkbyte () ; 
  377.     decr ( pkloc ) ;
  378.     dirptr = pxlloc ; 
  379.   for ( car = 0 ; car <= 127 ; car ++ ) 
  380.     { pixelinteger ( sizes [ car ] ) ; 
  381.       pixelinteger ( offsets [ car ] ) ; 
  382.       pixelinteger ( rasterpointer [ car ] ) ; 
  383.       pixelinteger ( tfmwidth [ car ] ) ; 
  384.       } 
  385.     pixelinteger ( checksum ) ; 
  386.   pixelinteger ( magnification ) ; 
  387.   pixelinteger ( designsize ) ; 
  388.   pixelinteger ( dirptr ) ; 
  389.   pixelinteger ( 1001 ) ; 
  390.   printf ( "%d bytes read from packed file.\n" , pkloc ) ; 
  391.   printf ( "%d bytes written to pixel file.\n" , pxlloc * 4 ) ; 
  392.   lab9999 : ; 
  393.   } 
  394.